home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1995 October / EnigmA AMIGA RUN 01 (1995)(G.R. Edizioni)(IT)[!][issue 1995-10][Aminet 7].iso / Aminet / dev / gcc / ixemul_src.lha / ixemul-41.0 / library / vfork.c < prev    next >
C/C++ Source or Header  |  1995-05-28  |  20KB  |  656 lines
  1. /*
  2.  *  This file is part of ixemul.library for the Amiga.
  3.  *  Copyright (C) 1991, 1992  Markus M. Wild
  4.  *  Portions Copyright (C) 1994 Rafael W. Luebbert
  5.  *
  6.  *  This library is free software; you can redistribute it and/or
  7.  *  modify it under the terms of the GNU Library General Public
  8.  *  License as published by the Free Software Foundation; either
  9.  *  version 2 of the License, or (at your option) any later version.
  10.  *
  11.  *  This library is distributed in the hope that it will be useful,
  12.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14.  *  Library General Public License for more details.
  15.  *
  16.  *  You should have received a copy of the GNU Library General Public
  17.  *  License along with this library; if not, write to the Free
  18.  *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  *
  20.  *  $Id: vfork.c,v 1.9 1994/06/19 15:18:29 rluebbert Exp $
  21.  *
  22.  *  $Log: vfork.c,v $
  23.  *  Revision 1.9  1994/06/19  15:18:29  rluebbert
  24.  *  *** empty log message ***
  25.  *
  26.  *  Revision 1.7  1992/10/20  16:29:49  mwild
  27.  *  allow a vfork'd process to use the parents memory pool. The new function
  28.  *  vfork2() continues to use the old semantics.
  29.  *
  30.  *  Revision 1.6  1992/09/14  01:48:11  mwild
  31.  *  move kmalloc() out of Forbid() (since the allocator is now Semaphore-based).
  32.  *  move errno assignment after sigsetmask (thanks Niklas!)
  33.  *  remove dead code
  34.  *
  35.  *  Revision 1.5  1992/08/09  21:01:43  amiga
  36.  *  change to 2.x header files
  37.  *  duplicate calling stack frame in vfork_resume() instead of just doing rts.
  38.  *  temporary abort calling 1.3 vfork, until that's fixed again (when???).
  39.  *
  40.  *  Revision 1.4  1992/07/04  19:24:12  mwild
  41.  *  get passing of environment right.
  42.  *  change ix_sleep() calls to new semantics.
  43.  *
  44.  * Revision 1.3  1992/05/18  12:26:25  mwild
  45.  * fixed bad typo that didn't close files before sending wait message.
  46.  * Set childs Input()/Output() to NIL:, we only keep the files in our
  47.  * own filetable.
  48.  *
  49.  * Revision 1.2  1992/05/18  01:02:31  mwild
  50.  * add temporary Delay(100) before CloseLibrary() in the child after
  51.  * vfork(), there seem to arrive some late packets (don't know why..)
  52.  * pass NIL: filehandles as Input()/Output() to the child, so that the
  53.  * real I/O-handles only depend on ix-filetable for usage-count
  54.  *
  55.  * Revision 1.1  1992/05/14  19:55:40  mwild
  56.  * Initial revision
  57.  *
  58.  */
  59.  
  60. #define KERNEL
  61. #include "ixemul.h"
  62. #include "kprintf.h"
  63.  
  64. #include <sys/syscall.h>
  65. #include <sys/resource.h>
  66. #include <sys/wait.h>
  67. #include <stddef.h>
  68. #include <setjmp.h>
  69.  
  70. void vfork_own_malloc ();
  71. void volatile vfork_longjmp (jmp_buf, int);
  72. extern char **dupvec (char **);
  73.  
  74. #include <utility/tagitem.h>
  75. #include <dos/dostags.h>
  76.  
  77.  
  78. #define    PRB_SAVEIO    0L    /* Don't free/check file handles on exit    */
  79. #define    PRB_CLOSESPLAT    1L    /* Close Splat file, must request explicitly    */
  80. #define    PRB_NOCLI    2L    /* Don't create a CLI process            */
  81. /*    PRB_INTERACTIVE    3L       This is now obsolete...            */
  82. #define    PRB_CODE    4L    /* Dangerous yet enticing            */
  83. #define    PRB_STDIO    5L    /* Do the stdio thing, splat = CON:Filename     */
  84.  
  85. #define    PRF_SAVEIO    (1L << PRB_SAVEIO)
  86. #define    PRF_CLOSESPLAT    (1L << PRB_CLOSESPLAT)
  87. #define    PRF_NOCLI    (1L << PRB_NOCLI)
  88. #define    PRF_CODE    (1L << PRB_CODE)
  89. #define    PRF_STDIO    (1L << PRB_STDIO)
  90.  
  91.  
  92. /* having it in a struct makes parameter passing easier */
  93.  
  94. struct reg_parms {
  95.   jmp_buf jb;
  96. };
  97.  
  98. struct vfork_msg {
  99.   struct Message     vm_msg;
  100.   struct Process    *vm_self;    /* for validation purposes (1.3, grrr) */
  101.   struct Process     *vm_pptr;
  102.   struct reg_parms     *vm_regs;    /* parents context to restore */
  103.   int            vm_own_malloc;
  104.   int             vm_rc;        /* 0 if the child started normally, else errno */
  105. };
  106.  
  107. struct death_msg {
  108.   struct MinNode    dm_node;
  109.   struct Process    *dm_child;
  110.   int            dm_pgrp;
  111.   int            dm_status;
  112.   struct rusage        dm_rusage;
  113. };
  114.  
  115. /* this is the new process generated by vfork () ! */
  116. static void
  117. launcher ()
  118. {
  119.   void *ixb = OpenLibrary ("ixemul.library", IX_VERSION);
  120.   struct Process *me = (struct Process *) FindTask (0);
  121.   struct vfork_msg *vm;
  122.   int omask;
  123.  
  124.   /* the launcher() generated by Arp's ASyncRun seems to get a weird
  125.      message. Verify that the message at least looks right.. (damn 1.3 support..) */
  126.   vm = 0;
  127.   do
  128.     {
  129.       if (! vm) 
  130.         WaitPort (& me->pr_MsgPort);
  131.       vm = (struct vfork_msg *) GetMsg (& me->pr_MsgPort);
  132.     }
  133.   while (vm->vm_self != me);
  134.       
  135.  
  136.   if (ixb)
  137.     {
  138.       /* get parents user area */
  139.       volatile struct user *pu = (struct user *) (vm->vm_pptr->pr_Task.tc_TrapData);
  140.       /* `my' user area. This way we don't have to recalculate it too often */
  141.       volatile struct user *mu = &u;
  142.       /* reaping the dup function of execve() ;-)) */
  143.       int fd, rc;
  144.  
  145.       /* link ourselves into the parents process lists. Guarantee single
  146.        * threaded access to those lists by locking out any other users of
  147.        * the library (nicer than to just call Forbid()) */
  148.       ix_lock_base ();
  149.       
  150.       /* our older sybling is the last recently created child of the parent */
  151.       mu->p_osptr = pu->p_cptr;
  152.       /* we have no younger sybling */
  153.       mu->p_ysptr = 0;
  154.       /* if we have an older sybling, point its `younger sybling' field at us */
  155.       if (mu->p_osptr)
  156.         {
  157.           struct user *ou = (struct user *) (mu->p_osptr->pr_Task.tc_TrapData);
  158.       ou->p_ysptr = me;
  159.     }
  160.       /* set the parents `last recently created child' field at us */
  161.       pu->p_cptr = me;
  162.  
  163.       /* inherit the process group of our parent */
  164.       mu->p_pgrp = pu->p_pgrp;
  165.       mu->p_pptr = vm->vm_pptr;
  166.  
  167.       /* if we got our own malloc list already, it is save to call malloc here.
  168.          If not, the stuff done here is postponed to either vfork_resume, or
  169.          execve */
  170.       if (vm->vm_own_malloc)
  171.     {
  172.       /* inherit these global variables. */
  173.       mu->u_environ = (char ***) malloc (4);
  174.       * mu->u_environ = dupvec (* pu->u_environ);
  175.       mu->u_errno   = (int *) malloc (4);
  176.       *mu->u_errno = 0;
  177.     }
  178.       else
  179.     {
  180.       /* borrow the variables of the parent */
  181.       mu->u_environ = pu->u_environ;
  182.       mu->u_errno = pu->u_errno;
  183.       
  184.       /* tell malloc to use the parents malloc lists */
  185.       mu->u_mdp = pu->u_mdp;
  186.     }
  187.  
  188.       
  189.       /* and inherit several other things as well, upto not including u_md */
  190.       bcopy (& pu->u_signal[0], & mu->u_signal[0],
  191.          offsetof (struct user, u_md) - offsetof (struct user, u_signal[0]));
  192.  
  193.       /* some things have been copied that should be reset */      
  194.       mu->p_flag &= ~SFREEA4;
  195.       bzero (& mu->u_ru, sizeof (struct rusage));
  196.       bzero (& mu->u_cru, sizeof (struct rusage));
  197.       bzero (& mu->u_timer[0], sizeof (struct itimerval)); /* just the REAL timer! */
  198.       syscall (SYS_gettimeofday, & mu->u_start, 0);
  199.       omask = vm->vm_rc;    /* signal mask to restore at the end */
  200.  
  201.       /* and adjust the open count of each of the copied filedescriptors */
  202.       for (fd = 0; fd < NOFILE; fd++)
  203.         if (mu->u_ofile[fd])
  204.           mu->u_ofile[fd]->f_count++;
  205.  
  206.       /* copying finished, allow other processes to vfork() as well ;-)) */
  207.       ix_unlock_base ();
  208.       
  209.       /* remember the message we have to reply when either _exit() or 
  210.        * execve() is called */
  211.       mu->p_vfork_msg = vm;
  212.       
  213.       vm->vm_rc = 0;
  214.  
  215.       mu->u_save_sp = (void *) get_sp ();
  216.  
  217.       /* we get here when the user does an _exit() 
  218.        * (so as well after execve() terminates !) */
  219.       if (rc = setjmp (mu->u_jmp_buf))
  220.         {
  221.       struct death_msg *dm = 0;
  222.       int i, errno_dummy;
  223.  
  224.       /* overkill? */
  225.       vfork_own_malloc ();
  226.  
  227.       /* reset `mu' in here, setjmp() might have clobbered it */
  228.       mu = &u;
  229.  
  230.       /* although this is done in CloseLibrary(), files should 
  231.          really be closed *before* a death-message is sent to
  232.          the parent. */
  233.       for (i = 0; i < NOFILE; i++) 
  234.         if (u.u_ofile[i]) syscall (SYS_close, i);
  235.  
  236.       /* free memory (look that most, best all memory is freed here, as
  237.              long as we're not inside Forbid. If memory is freed in CloseLibrary,
  238.          it may potentially have to wait for the memory semaphore in buddy-alloc.c,
  239.          thus breaking the Forbid! */
  240.       all_free ();
  241.  
  242.           /* Since errno (= *u.u_errno) is still used by ix_sleep we point it
  243.              to our own temporary errno dummy variable */
  244.           u.u_errno = &errno_dummy;
  245.       KPRINTF (("&errno = %lx, errno = %ld\n", &errno, errno));
  246.  
  247.       /* KPRINTF (("vforked: _exit in progress, rc = %ld.\n", rc)); */
  248.  
  249.       /* this whole thing only happens if our parent is still alive ! */
  250.       if (mu->p_pptr && mu->p_pptr != (struct Process *) 1)
  251.         {
  252.           rc --;
  253.  
  254.           /* KPRINTF (("vforked: parent alive, zombie-sig = %ld, vfork_msg = $%lx.\n",
  255.          pu->p_zombie_sig, mu->p_vfork_msg));*/
  256.  
  257.           pu = (struct user *) (mu->p_pptr->pr_Task.tc_TrapData);
  258.  
  259.           /* send the parent a death message with our return code */
  260.           dm = (struct death_msg *) kmalloc (sizeof (struct death_msg));
  261.  
  262.           Forbid ();
  263.           if (dm)
  264.         {
  265.           dm->dm_status = (rc >= 128) ? W_EXITCODE (0, rc & 0x7f) 
  266.                       : W_EXITCODE (rc, 0);
  267.           dm->dm_rusage = mu->u_ru;
  268.           ruadd (&dm->dm_rusage, &mu->u_cru);
  269.           dm->dm_child = (struct Process *) FindTask (0);
  270.           dm->dm_pgrp  = mu->p_pgrp;
  271.           KPRINTF (("vfork-exit: Adding child $%lx to $%lx\n", dm->dm_child, mu->p_pptr));
  272.           AddTail ((struct List *) &pu->p_zombies, (struct Node *) dm);
  273.         }
  274.  
  275.           _psignal (mu->p_pptr, SIGCHLD);
  276.           /* have to wakeup the parent `by hand' to make sure it gets
  277.              out of its sleep, since it might have SIGCHLD masked out or
  278.              ignored at the moment */
  279.           if (pu->p_stat == SSLEEP && pu->p_wchan == (caddr_t) pu)
  280.         ix_wakeup (pu);
  281.  
  282.           if (mu->p_vfork_msg)
  283.             ReplyMsg ((struct Message *) mu->p_vfork_msg);
  284.  
  285.           /* KPRINTF (("vforked: unlinking from parent process chains\n"));*/
  286.           /* unlink us from the parents process chains */
  287.  
  288.           if (mu->p_ysptr)
  289.             {
  290.               struct user *yu = (struct user *) (mu->p_ysptr->pr_Task.tc_TrapData);
  291.               yu->p_osptr = mu->p_osptr;
  292.             }
  293.  
  294.           if (mu->p_osptr)
  295.             {
  296.              struct user *ou = (struct user *) (mu->p_osptr->pr_Task.tc_TrapData);
  297.              ou->p_ysptr = mu->p_ysptr;
  298.             }
  299.  
  300.           if (pu->p_cptr == me)
  301.             pu->p_cptr = mu->p_osptr;
  302.  
  303.           /* moved this code into the if-block, as it should only be 
  304.              executed if there really is a parent that might wait for the
  305.              child to terminate (ignore that `this can't happen', perhaps
  306.              it does... */
  307.  
  308.           /* this seems to be necessary for process synchronisation, or
  309.              else it is possible that the same process address is
  310.              reused before the parent noticed the death of this child,
  311.              and this would rather confuse it (or ksh at least ;-)) */
  312.           if (dm)
  313.             ix_sleep (dm, "vfork-dm");
  314.         }
  315.       else
  316.         {
  317.           Forbid ();
  318.           KPRINTF (("vforked: couldn't send death_msg\n"));
  319.         }
  320.  
  321.       KPRINTF (("vforked: now closing library\n"));
  322.  
  323.       /* temporary `fix'.. there seem to be some packets arriving
  324.          too late.. */
  325.       Delay (100);
  326.  
  327.       CloseLibrary (ixb);
  328.  
  329.       KPRINTF (("vforked: falling off the edge of the world.\n"));
  330.       /* just fall off the edge of the world, this is a process */
  331.       return;
  332.         }
  333.  
  334.       syscall (SYS_sigsetmask, omask);
  335.  
  336.       KPRINTF (("vforked: jumping back\n"));
  337.  
  338.       /* jump into nevereverland ;-) */
  339.       vfork_longjmp (vm->vm_regs->jb, 0);
  340.       /* NOTREACHED */
  341.     }
  342.  
  343.   vm->vm_rc = ENOMEM; /* can't imagine any other reason why the OpenLib should fail */
  344.   ReplyMsg ((struct Message *) vm);
  345.   /* fall off the edge of the world ;-) */
  346. }
  347.  
  348.  
  349. /* This function is used by vfork_resume and execve. Perhaps it should be made
  350.    externally available? It causes the process to switch to its own malloc
  351.    list, and copies errno and environ into private space. */
  352. void
  353. vfork_own_malloc ()
  354. {
  355.   /* use volatile here, or the compiler might do wrong `optimization' .. */
  356.   volatile struct user *p = &u;
  357.   if (p->u_mdp != &p->u_md)
  358.     {
  359.       char **parent_environ = * p->u_environ;
  360.       
  361.       /* switch to our memory list (which is initialized by OpenLibrary) */
  362.       p->u_mdp = &p->u_md;
  363.       /* dupvec now uses malloc() on our list */
  364.       p->u_environ = (char ***) malloc (4);
  365.       *p->u_environ = dupvec (parent_environ);
  366.     }
  367. }
  368.  
  369.  
  370. /*
  371.  * this is an implementation extension to the `real' vfork2(). Normally you
  372.  * can only cause the parent to resume by calling _exit() or execve() from
  373.  * the child. Since I can't provide a real fork() on the Amiga, this function
  374.  * is a third possibility to make the parent resume. You have then two
  375.  * concurrent processes sharing the same frame and global data... Please be
  376.  * EXTREMELY careful what you may do and what not. vfork2() itself is a hack,
  377.  * this is an even greater one...
  378.  *
  379.  * DO NOT use this function in combination with vfork(), or you'll get a big
  380.  * memory leak. Only use it with vfork2().
  381.  *
  382.  * Note that this function should really be static, but if you make it static
  383.  * and compile it with "gcc -O4", it appears to go away completely.  This may
  384.  * be a bug in gcc 2.6.3 or it may not, but making it global works around
  385.  * the problem for now.  This should be tracked down and either the gcc
  386.  * bug fixed, or the makefile changed to treat vfork specially.  FIXME-fnf
  387.  *
  388.  */
  389.  
  390. /* static */ void
  391. _vfork_resume (u_int *copy_from_sp)
  392. {
  393.   struct vfork_msg **vm = &u.p_vfork_msg;
  394.  
  395.   if (*vm)
  396.     {
  397.       u_int *sp = (u_int *)u.u_save_sp;
  398.       u_int *copy_till_sp = (u_int *)get_sp ();
  399.  
  400.       /* be sure to switch to our memory list */
  401.       vfork_own_malloc ();
  402.  
  403.       /* copy the stack frame */
  404.       copy_from_sp++;
  405.       do
  406.     *--sp = *--copy_from_sp;
  407.       while (copy_from_sp > copy_till_sp);
  408.  
  409.       set_sp ((u_int) sp);
  410.  
  411.       ReplyMsg ((struct Message *) *vm);
  412.       *vm = 0;
  413.     }
  414. }
  415.  
  416.  
  417. asm ("
  418.     .globl _vfork
  419.     .globl _vfork2
  420.     .globl _vfork_resume
  421. _vfork:
  422.     | store a setjmp () compatible frame on the stack to pass to _vfork ()
  423.     lea    sp@(-18*4),sp        | _JBLEN (17) longs on the stack
  424.     pea    sp@
  425.     jbsr    _setjmp
  426.     lea    sp@(4),sp
  427.     | now patch sp and pc, since they differ
  428.     addl    #20*4,sp@(8)        | account for buffer space
  429.     movel    sp@(18*4),sp@(20)    | insert real PC (return addr on stack)
  430.     | tell _vfork *not* yet to switch to own malloc-list
  431.     pea    0
  432.     bsr    __vfork
  433.     lea    sp@(18*4 + 4),sp
  434.     rts
  435.  
  436. _vfork2:
  437.     | this is the vfork used in older versions of the library
  438.     lea    sp@(-18*4),sp        | _JBLEN (17) longs on the stack
  439.     pea    sp@
  440.     jbsr    _setjmp
  441.     lea    sp@(4),sp
  442.     | now patch sp and pc, since they differ
  443.     addl    #20*4,sp@(8)        | account for buffer space
  444.     movel    sp@(18*4),sp@(20)    | insert real PC (return addr on stack)
  445.     | tell _vfork to have the child run with own malloc-list.
  446.     pea    1
  447.     bsr    __vfork
  448.     lea    sp@(18*4 + 4),sp
  449.     rts
  450.  
  451.  
  452.     | the following is longjmp(), with the subtle difference that this
  453.     | thing doesn't insist in returning something non-zero... 
  454. _vfork_longjmp:
  455.     movel    sp@(4),a0    /* save area pointer */
  456.     tstl    a0@(8)        /* ensure non-zero SP */
  457.     jeq    Lbotch        /* oops! */
  458.     movel    sp@(8),d0    /* grab return value */
  459.     moveml    a0@(28),d2-d7/a2-a4/a6    /* restore non-scratch regs */
  460.     movel    a0,sp@-        /* let sigreturn */
  461.     jbsr    _sigreturn    /*   finish for us */
  462.  
  463. Lbotch:
  464.     jsr    _longjmperror
  465.     stop    #0
  466.  
  467. _vfork_resume:
  468.     pea    sp@        | pass the sp containing the return address
  469.     bsr    __vfork_resume
  470.     lea    sp@(4),sp
  471.     rts
  472. ");
  473.  
  474. static int
  475. _vfork (int own_malloc, struct reg_parms rp)
  476. {
  477.   struct Process *me = (struct Process *) FindTask(0);
  478.   struct CommandLineInterface *CLI = BTOCPTR (me->pr_CLI);
  479.   u_int stack_size = CLI ? CLI->cli_DefaultStack * 4 : me->pr_StackSize;
  480.   BPTR input, output;
  481.   /* those *have* to be in registers to survive the stack deallocation */
  482.   register struct vfork_msg *vm asm ("a2");
  483.   register int omask asm ("d2");
  484.   register struct Process *child asm ("a3");
  485.   struct TagItem tags [] = {
  486.     { NP_Entry, (ULONG) launcher, },
  487.     { NP_Cli, (ULONG) (CLI ? -1 : 0), },    /* same thing we are */
  488.     { NP_Name, (ULONG) "vfork()'d process", },    /* to be overridden by execve() */
  489.     { NP_StackSize, stack_size, },        /* same size we use */
  490.     { TAG_END, 0, }
  491.   };
  492.   KPRINTF (("vfork: creating child with stacksize = $%lx[$%lx,$%lx]\n", stack_size, tags[3]));
  493.   vm = (struct vfork_msg *) kmalloc (sizeof (struct vfork_msg));
  494.   if (! vm)
  495.     {
  496.       errno = ENOMEM;
  497.       KPRINTF (("&errno = %lx, errno = %ld\n", &errno, errno));
  498.       return -1;
  499.     }
  500.  
  501.   vm->vm_msg.mn_ReplyPort = u.u_sync_mp;
  502.   vm->vm_msg.mn_Node.ln_Type = NT_MESSAGE;
  503.   vm->vm_msg.mn_Length = sizeof (struct vfork_msg);
  504.   vm->vm_pptr = me;
  505.   vm->vm_own_malloc = own_malloc;
  506.   vm->vm_regs = & rp;
  507.  
  508.   /* we have to block all signals as long as the child uses our resources.
  509.    * but since the child needs to start with the signal mask BEFORE this
  510.    * general blocking, we have to pass it the old signal mask. This is a
  511.    * way to do it */
  512.   vm->vm_rc   = 
  513.   omask      = syscall (SYS_sigsetmask, ~0);
  514.  
  515.   /* save the passed frame in our user structure, since the child will
  516.      deallocate it from the stack when it `returns' to user code */
  517.   bcopy (&rp, &u.u_vfork_frame, sizeof (rp));
  518.  
  519.   KPRINTF (("vfork: creating child with stacksize = $%lx[$%lx,$%lx]\n", stack_size, tags[3]));
  520.   child = CreateNewProc (tags);
  521.  
  522.  
  523.   if (! child)
  524.     {
  525.       /* do I have to close input/output here? Or does the startup close
  526.          them no matter whether it succeeds or not ? */
  527.       kfree (vm);
  528.       syscall (SYS_sigsetmask, omask);
  529.       errno = EPROCLIM;
  530.       KPRINTF (("&errno = %lx, errno = %ld\n", &errno, errno));
  531.       return -1;
  532.     }
  533.  
  534.   /* As soon as this message is dispatched, the child will `return' and 
  535.      deallocate the stack we're running on. So afterwards, *only* use
  536.      register variables and then longjmp () back.
  537.      Since we don't have a stack until after the longjmp(), temporarily
  538.      switch to our mini-stack */
  539.   set_sp ((u_int) &u.u_mini_stack[sizeof (u.u_mini_stack) / sizeof (long)]);
  540.  
  541.   vm->vm_self = child;
  542.   PutMsg (& child->pr_MsgPort, (struct Message *) vm);
  543.   /* wait until the child does execve() or _exit() */
  544.   WaitPort (u.u_sync_mp);
  545.   GetMsg (u.u_sync_mp);
  546.   syscall (SYS_sigsetmask, omask);
  547.  
  548.   if (vm->vm_rc)
  549.     {
  550.       errno = (int) vm->vm_rc;
  551.       KPRINTF (("&errno = %lx, errno = %ld\n", &errno, errno));
  552.       child = (struct Process *) -1;
  553.     }
  554.       
  555.   /* this is the parent return, so we pass the id of the new child */
  556.   kfree (vm);
  557.   /* could use longjmp() here, but since we already *have* the local one.. */
  558.   vfork_longjmp (u.u_vfork_frame, (int) child);
  559. }
  560.  
  561.   
  562. ruadd(ru, ru2)
  563.     register struct rusage *ru, *ru2;
  564. {
  565.     register long *ip, *ip2;
  566.     register int i;
  567.  
  568.     timevaladd(&ru->ru_utime, &ru2->ru_utime);
  569.     timevaladd(&ru->ru_stime, &ru2->ru_stime);
  570.     if (ru->ru_maxrss < ru2->ru_maxrss)
  571.         ru->ru_maxrss = ru2->ru_maxrss;
  572.     ip = &ru->ru_first; ip2 = &ru2->ru_first;
  573.     for (i = &ru->ru_last - &ru->ru_first; i > 0; i--)
  574.         *ip++ += *ip2++;
  575. }
  576.  
  577.  
  578. /* This function is in desperate need of redesign !!!! */
  579.  
  580. int
  581. wait4 (int pid, int *status, int options, struct rusage *rusage)
  582. {
  583.   struct Process * me = (struct Process *) FindTask (0);
  584.   struct user * mu = (struct user *) me->pr_Task.tc_TrapData;
  585.   int omask;
  586.  
  587.   for (;;)
  588.     {
  589.       int err = 0, omask;
  590.       struct death_msg *dm, *ndm;
  591.       int got_node;
  592.  
  593.       got_node = 0;
  594.       Forbid ();
  595.       
  596.       for (dm  = (struct death_msg *) mu->p_zombies.mlh_Head;
  597.          ndm = (struct death_msg *) dm->dm_node.mln_Succ;
  598.          dm  = ndm)
  599.       if (pid == -1 ||
  600.           (pid == 0 && dm->dm_pgrp == mu->p_pgrp) ||
  601.         (pid < -1 && dm->dm_pgrp == - pid) ||
  602.         (pid == (int) dm->dm_child))
  603.       {
  604.         got_node = 1;
  605.         Remove ((struct Node *) dm);
  606.         break;
  607.       }
  608.  
  609.       if (!got_node && !mu->p_cptr)
  610.     err = ECHILD;
  611.  
  612.       if (got_node)
  613.         {
  614.       struct Process *child;
  615.  
  616.       KPRINTF (("wait4: unlinking child $%lx\n", dm->dm_child));
  617.       ix_wakeup (dm);
  618.       Permit ();
  619.  
  620.           if (status)
  621.             *status = dm->dm_status;
  622.           if (rusage)
  623.             *rusage = dm->dm_rusage;
  624.  
  625.       child = dm->dm_child;
  626.  
  627.       kfree (dm);
  628.  
  629.           return (int) child;
  630.     }
  631.  
  632.       if (!got_node && err)
  633.     {
  634.       Permit ();
  635.       errno = err;
  636.       KPRINTF (("&errno = %lx, errno = %ld\n", &errno, errno));
  637.       return -1;
  638.     }
  639.  
  640.       if (options & WNOHANG)
  641.     {
  642.       Permit ();
  643.       return 0;
  644.     }
  645.  
  646.       KPRINTF (("wait4: waiting for SIGCHLD\n"));
  647.       ix_sleep (mu, "wait4");
  648.       if (mu->p_sig)
  649.     err = EINTR;
  650.  
  651.       Permit ();
  652.       if (CURSIG (mu))
  653.         setrun (me);
  654.     }
  655. }
  656.